/*
 *  jQuery OwlCarousel v1.3.3
 *
 *  Copyright (c) 2013 Bartosz Wojciechowski
 *  http://www.owlgraphic.com/owlcarousel/
 *
 *  Licensed under MIT
 *
 */

/*JS Lint helpers: */
/*global dragMove: false, dragEnd: false, $, jQuery, alert, window, document */
/*jslint nomen: true, continue:true */
define([
    'jquery'
], function () {
    if (typeof Object.create !== "function") {
        Object.create = function (obj) {
            function F() {
            }
            F.prototype = obj;
            return new F();
        };
    }
    (function ($, window, document) {

        var Carousel = {
            init: function (options, el) {
                var base = this;

                base.$elem = $(el);
                base.options = $.extend({}, $.fn.owlCarousel.options, base.$elem.data(), options);

                base.userOptions = options;
                base.loadContent();
            },
            loadContent: function () {
                var base = this, url;

                function getData(data) {
                    var i, content = "";
                    if (typeof base.options.jsonSuccess === "function") {
                        base.options.jsonSuccess.apply(this, [data]);
                    } else {
                        for (i in data.owl) {
                            if (data.owl.hasOwnProperty(i)) {
                                content += data.owl[i].item;
                            }
                        }
                        base.$elem.html(content);
                    }
                    base.logIn();
                }

                if (typeof base.options.beforeInit === "function") {
                    base.options.beforeInit.apply(this, [base.$elem]);
                }

                if (typeof base.options.jsonPath === "string") {
                    url = base.options.jsonPath;
                    $.getJSON(url, getData);
                } else {
                    base.logIn();
                }
            },
            logIn: function () {
                var base = this;

                base.$elem.data("owl-originalStyles", base.$elem.attr("style"));
                base.$elem.data("owl-originalClasses", base.$elem.attr("class"));

                base.$elem.css({opacity: 0});
                base.orignalItems = base.options.items;
                base.checkBrowser();
                base.wrapperWidth = 0;
                base.checkVisible = null;
                base.setVars();
            },
            setVars: function () {
                var base = this;
                if (base.$elem.children().length === 0) {
                    return false;
                }
                base.baseClass();
                base.eventTypes();
                base.$userItems = base.$elem.children();
                base.itemsAmount = base.$userItems.length;
                base.wrapItems();
                base.$owlItems = base.$elem.find(".owl-item");
                base.$owlWrapper = base.$elem.find(".owl-wrapper");
                base.playDirection = "next";
                base.prevItem = 0;
                base.prevArr = [0];
                base.currentItem = 0;
                base.customEvents();
                base.onStartup();
            },
            onStartup: function () {
                var base = this;
                base.updateItems();
                base.calculateAll();
                base.buildControls();
                base.updateControls();
                base.response();
                base.moveEvents();
                base.stopOnHover();
                base.owlStatus();

                if (base.options.transitionStyle !== false) {
                    base.transitionTypes(base.options.transitionStyle);
                }
                if (base.options.autoPlay === true) {
                    base.options.autoPlay = 5000;
                }
                base.play();

                base.$elem.find(".owl-wrapper").css("display", "block");

                if (!base.$elem.is(":visible")) {
                    base.watchVisibility();
                } else {
                    base.$elem.css("opacity", 1);
                }
                base.onstartup = false;
                base.eachMoveUpdate();
                if (typeof base.options.afterInit === "function") {
                    base.options.afterInit.apply(this, [base.$elem]);
                }
            },
            eachMoveUpdate: function () {
                var base = this;

                if (base.options.lazyLoad === true) {
                    base.lazyLoad();
                }
                if (base.options.autoHeight === true) {
                    base.autoHeight();
                }
                base.onVisibleItems();

                if (typeof base.options.afterAction === "function") {
                    base.options.afterAction.apply(this, [base.$elem]);
                }
            },
            updateVars: function () {
                var base = this;
                if (typeof base.options.beforeUpdate === "function") {
                    base.options.beforeUpdate.apply(this, [base.$elem]);
                }
                base.watchVisibility();
                base.updateItems();
                base.calculateAll();
                base.updatePosition();
                base.updateControls();
                base.eachMoveUpdate();
                if (typeof base.options.afterUpdate === "function") {
                    base.options.afterUpdate.apply(this, [base.$elem]);
                }
            },
            reload: function () {
                var base = this;
                window.setTimeout(function () {
                    base.updateVars();
                }, 0);
            },
            watchVisibility: function () {
                var base = this;

                if (base.$elem.is(":visible") === false) {
                    base.$elem.css({opacity: 0});
                    window.clearInterval(base.autoPlayInterval);
                    window.clearInterval(base.checkVisible);
                } else {
                    return false;
                }
                base.checkVisible = window.setInterval(function () {
                    if (base.$elem.is(":visible")) {
                        base.reload();
                        base.$elem.animate({opacity: 1}, 200);
                        window.clearInterval(base.checkVisible);
                    }
                }, 500);
            },
            wrapItems: function () {
                var base = this;
                base.$userItems.wrapAll("<div class=\"owl-wrapper\">").wrap("<div class=\"owl-item\"></div>");
                base.$elem.find(".owl-wrapper").wrap("<div class=\"owl-wrapper-outer\">");
                base.wrapperOuter = base.$elem.find(".owl-wrapper-outer");
                base.$elem.css("display", "block");
            },
            baseClass: function () {
                var base = this,
                        hasBaseClass = base.$elem.hasClass(base.options.baseClass),
                        hasThemeClass = base.$elem.hasClass(base.options.theme);

                if (!hasBaseClass) {
                    base.$elem.addClass(base.options.baseClass);
                }

                if (!hasThemeClass) {
                    base.$elem.addClass(base.options.theme);
                }
            },
            updateItems: function () {
                var base = this, width, i;

                if (base.options.responsive === false) {
                    return false;
                }
                if (base.options.singleItem === true) {
                    base.options.items = base.orignalItems = 1;
                    base.options.itemsCustom = false;
                    base.options.itemsDesktop = false;
                    base.options.itemsDesktopSmall = false;
                    base.options.itemsTablet = false;
                    base.options.itemsTabletSmall = false;
                    base.options.itemsMobile = false;
                    return false;
                }

                width = $(base.options.responsiveBaseWidth).width();

                if (width > (base.options.itemsDesktop[0] || base.orignalItems)) {
                    base.options.items = base.orignalItems;
                }
                if (base.options.itemsCustom !== false) {
                    //Reorder array by screen size
                    base.options.itemsCustom.sort(function (a, b) {
                        return a[0] - b[0];
                    });

                    for (i = 0; i < base.options.itemsCustom.length; i += 1) {
                        if (base.options.itemsCustom[i][0] <= width) {
                            base.options.items = base.options.itemsCustom[i][1];
                        }
                    }

                } else {

                    if (width <= base.options.itemsDesktop[0] && base.options.itemsDesktop !== false) {
                        base.options.items = base.options.itemsDesktop[1];
                    }

                    if (width <= base.options.itemsDesktopSmall[0] && base.options.itemsDesktopSmall !== false) {
                        base.options.items = base.options.itemsDesktopSmall[1];
                    }

                    if (width <= base.options.itemsTablet[0] && base.options.itemsTablet !== false) {
                        base.options.items = base.options.itemsTablet[1];
                    }

                    if (width <= base.options.itemsTabletSmall[0] && base.options.itemsTabletSmall !== false) {
                        base.options.items = base.options.itemsTabletSmall[1];
                    }

                    if (width <= base.options.itemsMobile[0] && base.options.itemsMobile !== false) {
                        base.options.items = base.options.itemsMobile[1];
                    }
                }

                //if number of items is less than declared
                if (base.options.items > base.itemsAmount && base.options.itemsScaleUp === true) {
                    base.options.items = base.itemsAmount;
                }
            },
            response: function () {
                var base = this,
                        smallDelay,
                        lastWindowWidth;

                if (base.options.responsive !== true) {
                    return false;
                }
                lastWindowWidth = $(window).width();

                base.resizer = function () {
                    if ($(window).width() !== lastWindowWidth) {
                        if (base.options.autoPlay !== false) {
                            window.clearInterval(base.autoPlayInterval);
                        }
                        window.clearTimeout(smallDelay);
                        smallDelay = window.setTimeout(function () {
                            lastWindowWidth = $(window).width();
                            base.updateVars();
                        }, base.options.responsiveRefreshRate);
                    }
                };
                $(window).resize(base.resizer);
            },
            updatePosition: function () {
                var base = this;
                base.jumpTo(base.currentItem);
                if (base.options.autoPlay !== false) {
                    base.checkAp();
                }
            },
            appendItemsSizes: function () {
                var base = this,
                        roundPages = 0,
                        lastItem = base.itemsAmount - base.options.items;

                base.$owlItems.each(function (index) {
                    var $this = $(this);
                    $this
                            .css({"width": base.itemWidth})
                            .data("owl-item", Number(index));

                    if (index % base.options.items === 0 || index === lastItem) {
                        if (!(index > lastItem)) {
                            roundPages += 1;
                        }
                    }
                    $this.data("owl-roundPages", roundPages);
                });
            },
            appendWrapperSizes: function () {
                var base = this,
                        width = base.$owlItems.length * base.itemWidth;

                base.$owlWrapper.css({
                    "width": width * 2,
                    "left": 0
                });
                base.appendItemsSizes();
            },
            calculateAll: function () {
                var base = this;
                base.calculateWidth();
                base.appendWrapperSizes();
                base.loops();
                base.max();
            },
            calculateWidth: function () {
                var base = this;
                base.itemWidth = Math.round(base.$elem.width() / base.options.items);
            },
            max: function () {
                var base = this,
                        maximum = ((base.itemsAmount * base.itemWidth) - base.options.items * base.itemWidth) * -1;
                if (base.options.items > base.itemsAmount) {
                    base.maximumItem = 0;
                    maximum = 0;
                    base.maximumPixels = 0;
                } else {
                    base.maximumItem = base.itemsAmount - base.options.items;
                    base.maximumPixels = maximum;
                }
                return maximum;
            },
            min: function () {
                return 0;
            },
            loops: function () {
                var base = this,
                        prev = 0,
                        elWidth = 0,
                        i,
                        item,
                        roundPageNum;

                base.positionsInArray = [0];
                base.pagesInArray = [];

                for (i = 0; i < base.itemsAmount; i += 1) {
                    elWidth += base.itemWidth;
                    base.positionsInArray.push(-elWidth);

                    if (base.options.scrollPerPage === true) {
                        item = $(base.$owlItems[i]);
                        roundPageNum = item.data("owl-roundPages");
                        if (roundPageNum !== prev) {
                            base.pagesInArray[prev] = base.positionsInArray[i];
                            prev = roundPageNum;
                        }
                    }
                }
            },
            buildControls: function () {
                var base = this;
                if (base.options.navigation === true || base.options.pagination === true) {
                    base.owlControls = $("<div class=\"owl-controls\"/>").toggleClass("clickable", !base.browser.isTouch).appendTo(base.$elem);
                }
                if (base.options.pagination === true) {
                    base.buildPagination();
                }
                if (base.options.navigation === true) {
                    base.buildButtons();
                }
            },
            buildButtons: function () {
                var base = this,
                        buttonsWrapper = $("<div class=\"owl-buttons\"/>");
                base.owlControls.append(buttonsWrapper);

                base.buttonPrev = $("<div/>", {
                    "class": "owl-prev",
                    "html": base.options.navigationText[0] || ""
                });

                base.buttonNext = $("<div/>", {
                    "class": "owl-next",
                    "html": base.options.navigationText[1] || ""
                });

                buttonsWrapper
                        .append(base.buttonPrev)
                        .append(base.buttonNext);

                buttonsWrapper.on("touchstart.owlControls mousedown.owlControls", "div[class^=\"owl\"]", function (event) {
                    event.preventDefault();
                });

                buttonsWrapper.on("touchend.owlControls mouseup.owlControls", "div[class^=\"owl\"]", function (event) {
                    event.preventDefault();
                    if ($(this).hasClass("owl-next")) {
                        base.next();
                    } else {
                        base.prev();
                    }
                });
            },
            buildPagination: function () {
                var base = this;

                base.paginationWrapper = $("<div class=\"owl-pagination\"/>");
                base.owlControls.append(base.paginationWrapper);

                base.paginationWrapper.on("touchend.owlControls mouseup.owlControls", ".owl-page", function (event) {
                    event.preventDefault();
                    if (Number($(this).data("owl-page")) !== base.currentItem) {
                        base.goTo(Number($(this).data("owl-page")), true);
                    }
                });
            },
            updatePagination: function () {
                var base = this,
                        counter,
                        lastPage,
                        lastItem,
                        i,
                        paginationButton,
                        paginationButtonInner;

                if (base.options.pagination === false) {
                    return false;
                }

                base.paginationWrapper.html("");

                counter = 0;
                lastPage = base.itemsAmount - base.itemsAmount % base.options.items;

                for (i = 0; i < base.itemsAmount; i += 1) {
                    if (i % base.options.items === 0) {
                        counter += 1;
                        if (lastPage === i) {
                            lastItem = base.itemsAmount - base.options.items;
                        }
                        paginationButton = $("<div/>", {
                            "class": "owl-page"
                        });
                        paginationButtonInner = $("<span></span>", {
                            "text": base.options.paginationNumbers === true ? counter : "",
                            "class": base.options.paginationNumbers === true ? "owl-numbers" : ""
                        });
                        paginationButton.append(paginationButtonInner);

                        paginationButton.data("owl-page", lastPage === i ? lastItem : i);
                        paginationButton.data("owl-roundPages", counter);

                        base.paginationWrapper.append(paginationButton);
                    }
                }
                base.checkPagination();
            },
            checkPagination: function () {
                var base = this;
                if (base.options.pagination === false) {
                    return false;
                }
                base.paginationWrapper.find(".owl-page").each(function () {
                    if ($(this).data("owl-roundPages") === $(base.$owlItems[base.currentItem]).data("owl-roundPages")) {
                        base.paginationWrapper
                                .find(".owl-page")
                                .removeClass("active");
                        $(this).addClass("active");
                    }
                });
            },
            checkNavigation: function () {
                var base = this;

                if (base.options.navigation === false) {
                    return false;
                }
                if (base.options.rewindNav === false) {
                    if (base.currentItem === 0 && base.maximumItem === 0) {
                        base.buttonPrev.addClass("disabled");
                        base.buttonNext.addClass("disabled");
                    } else if (base.currentItem === 0 && base.maximumItem !== 0) {
                        base.buttonPrev.addClass("disabled");
                        base.buttonNext.removeClass("disabled");
                    } else if (base.currentItem === base.maximumItem) {
                        base.buttonPrev.removeClass("disabled");
                        base.buttonNext.addClass("disabled");
                    } else if (base.currentItem !== 0 && base.currentItem !== base.maximumItem) {
                        base.buttonPrev.removeClass("disabled");
                        base.buttonNext.removeClass("disabled");
                    }
                }
            },
            updateControls: function () {
                var base = this;
                base.updatePagination();
                base.checkNavigation();
                if (base.owlControls) {
                    if (base.options.items >= base.itemsAmount) {
                        base.owlControls.hide();
                    } else {
                        base.owlControls.show();
                    }
                }
            },
            destroyControls: function () {
                var base = this;
                if (base.owlControls) {
                    base.owlControls.remove();
                }
            },
            next: function (speed) {
                var base = this;

                if (base.isTransition) {
                    return false;
                }

                base.currentItem += base.options.scrollPerPage === true ? base.options.items : 1;
                if (base.currentItem > base.maximumItem + (base.options.scrollPerPage === true ? (base.options.items - 1) : 0)) {
                    if (base.options.rewindNav === true) {
                        base.currentItem = 0;
                        speed = "rewind";
                    } else {
                        base.currentItem = base.maximumItem;
                        return false;
                    }
                }
                base.goTo(base.currentItem, speed);
            },
            prev: function (speed) {
                var base = this;

                if (base.isTransition) {
                    return false;
                }

                if (base.options.scrollPerPage === true && base.currentItem > 0 && base.currentItem < base.options.items) {
                    base.currentItem = 0;
                } else {
                    base.currentItem -= base.options.scrollPerPage === true ? base.options.items : 1;
                }
                if (base.currentItem < 0) {
                    if (base.options.rewindNav === true) {
                        base.currentItem = base.maximumItem;
                        speed = "rewind";
                    } else {
                        base.currentItem = 0;
                        return false;
                    }
                }
                base.goTo(base.currentItem, speed);
            },
            goTo: function (position, speed, drag) {
                var base = this,
                        goToPixel;

                if (base.isTransition) {
                    return false;
                }
                if (typeof base.options.beforeMove === "function") {
                    base.options.beforeMove.apply(this, [base.$elem]);
                }
                if (position >= base.maximumItem) {
                    position = base.maximumItem;
                } else if (position <= 0) {
                    position = 0;
                }

                base.currentItem = base.owl.currentItem = position;
                if (base.options.transitionStyle !== false && drag !== "drag" && base.options.items === 1 && base.browser.support3d === true) {
                    base.swapSpeed(0);
                    if (base.browser.support3d === true) {
                        base.transition3d(base.positionsInArray[position]);
                    } else {
                        base.css2slide(base.positionsInArray[position], 1);
                    }
                    base.afterGo();
                    base.singleItemTransition();
                    return false;
                }
                goToPixel = base.positionsInArray[position];

                if (base.browser.support3d === true) {
                    base.isCss3Finish = false;

                    if (speed === true) {
                        base.swapSpeed("paginationSpeed");
                        window.setTimeout(function () {
                            base.isCss3Finish = true;
                        }, base.options.paginationSpeed);

                    } else if (speed === "rewind") {
                        base.swapSpeed(base.options.rewindSpeed);
                        window.setTimeout(function () {
                            base.isCss3Finish = true;
                        }, base.options.rewindSpeed);

                    } else {
                        base.swapSpeed("slideSpeed");
                        window.setTimeout(function () {
                            base.isCss3Finish = true;
                        }, base.options.slideSpeed);
                    }
                    base.transition3d(goToPixel);
                } else {
                    if (speed === true) {
                        base.css2slide(goToPixel, base.options.paginationSpeed);
                    } else if (speed === "rewind") {
                        base.css2slide(goToPixel, base.options.rewindSpeed);
                    } else {
                        base.css2slide(goToPixel, base.options.slideSpeed);
                    }
                }
                base.afterGo();
            },
            jumpTo: function (position) {
                var base = this;
                if (typeof base.options.beforeMove === "function") {
                    base.options.beforeMove.apply(this, [base.$elem]);
                }
                if (position >= base.maximumItem || position === -1) {
                    position = base.maximumItem;
                } else if (position <= 0) {
                    position = 0;
                }
                base.swapSpeed(0);
                if (base.browser.support3d === true) {
                    base.transition3d(base.positionsInArray[position]);
                } else {
                    base.css2slide(base.positionsInArray[position], 1);
                }
                base.currentItem = base.owl.currentItem = position;
                base.afterGo();
            },
            afterGo: function () {
                var base = this;

                base.prevArr.push(base.currentItem);
                base.prevItem = base.owl.prevItem = base.prevArr[base.prevArr.length - 2];
                base.prevArr.shift(0);

                if (base.prevItem !== base.currentItem) {
                    base.checkPagination();
                    base.checkNavigation();
                    base.eachMoveUpdate();

                    if (base.options.autoPlay !== false) {
                        base.checkAp();
                    }
                }
                if (typeof base.options.afterMove === "function" && base.prevItem !== base.currentItem) {
                    base.options.afterMove.apply(this, [base.$elem]);
                }
            },
            stop: function () {
                var base = this;
                base.apStatus = "stop";
                window.clearInterval(base.autoPlayInterval);
            },
            checkAp: function () {
                var base = this;
                if (base.apStatus !== "stop") {
                    base.play();
                }
            },
            play: function () {
                var base = this;
                base.apStatus = "play";
                if (base.options.autoPlay === false) {
                    return false;
                }
                window.clearInterval(base.autoPlayInterval);
                base.autoPlayInterval = window.setInterval(function () {
                    base.next(true);
                }, base.options.autoPlay);
            },
            swapSpeed: function (action) {
                var base = this;
                if (action === "slideSpeed") {
                    base.$owlWrapper.css(base.addCssSpeed(base.options.slideSpeed));
                } else if (action === "paginationSpeed") {
                    base.$owlWrapper.css(base.addCssSpeed(base.options.paginationSpeed));
                } else if (typeof action !== "string") {
                    base.$owlWrapper.css(base.addCssSpeed(action));
                }
            },
            addCssSpeed: function (speed) {
                return {
                    "-webkit-transition": "all " + speed + "ms ease",
                    "-moz-transition": "all " + speed + "ms ease",
                    "-o-transition": "all " + speed + "ms ease",
                    "transition": "all " + speed + "ms ease"
                };
            },
            removeTransition: function () {
                return {
                    "-webkit-transition": "",
                    "-moz-transition": "",
                    "-o-transition": "",
                    "transition": ""
                };
            },
            doTranslate: function (pixels) {
                return {
                    "-webkit-transform": "translate3d(" + pixels + "px, 0px, 0px)",
                    "-moz-transform": "translate3d(" + pixels + "px, 0px, 0px)",
                    "-o-transform": "translate3d(" + pixels + "px, 0px, 0px)",
                    "-ms-transform": "translate3d(" + pixels + "px, 0px, 0px)",
                    "transform": "translate3d(" + pixels + "px, 0px,0px)"
                };
            },
            transition3d: function (value) {
                var base = this;
                base.$owlWrapper.css(base.doTranslate(value));
            },
            css2move: function (value) {
                var base = this;
                base.$owlWrapper.css({"left": value});
            },
            css2slide: function (value, speed) {
                var base = this;

                base.isCssFinish = false;
                base.$owlWrapper.stop(true, true).animate({
                    "left": value
                }, {
                    duration: speed || base.options.slideSpeed,
                    complete: function () {
                        base.isCssFinish = true;
                    }
                });
            },
            checkBrowser: function () {
                var base = this,
                        translate3D = "translate3d(0px, 0px, 0px)",
                        tempElem = document.createElement("div"),
                        regex,
                        asSupport,
                        support3d,
                        isTouch;

                tempElem.style.cssText = "  -moz-transform:" + translate3D +
                        "; -ms-transform:" + translate3D +
                        "; -o-transform:" + translate3D +
                        "; -webkit-transform:" + translate3D +
                        "; transform:" + translate3D;
                regex = /translate3d\(0px, 0px, 0px\)/g;
                asSupport = tempElem.style.cssText.match(regex);
                support3d = (asSupport !== null && asSupport.length === 1);

                isTouch = "ontouchstart" in window || window.navigator.msMaxTouchPoints;

                base.browser = {
                    "support3d": support3d,
                    "isTouch": isTouch
                };
            },
            moveEvents: function () {
                var base = this;
                if (base.options.mouseDrag !== false || base.options.touchDrag !== false) {
                    base.gestures();
                    base.disabledEvents();
                }
            },
            eventTypes: function () {
                var base = this,
                        types = ["s", "e", "x"];

                base.ev_types = {};

                if (base.options.mouseDrag === true && base.options.touchDrag === true) {
                    types = [
                        "touchstart.owl mousedown.owl",
                        "touchmove.owl mousemove.owl",
                        "touchend.owl touchcancel.owl mouseup.owl"
                    ];
                } else if (base.options.mouseDrag === false && base.options.touchDrag === true) {
                    types = [
                        "touchstart.owl",
                        "touchmove.owl",
                        "touchend.owl touchcancel.owl"
                    ];
                } else if (base.options.mouseDrag === true && base.options.touchDrag === false) {
                    types = [
                        "mousedown.owl",
                        "mousemove.owl",
                        "mouseup.owl"
                    ];
                }

                base.ev_types.start = types[0];
                base.ev_types.move = types[1];
                base.ev_types.end = types[2];
            },
            disabledEvents: function () {
                var base = this;
                base.$elem.on("dragstart.owl", function (event) {
                    event.preventDefault();
                });
                base.$elem.on("mousedown.disableTextSelect", function (e) {
                    return $(e.target).is('input, textarea, select, option');
                });
            },
            gestures: function () {
                /*jslint unparam: true*/
                var base = this,
                        locals = {
                            offsetX: 0,
                            offsetY: 0,
                            baseElWidth: 0,
                            relativePos: 0,
                            position: null,
                            minSwipe: null,
                            maxSwipe: null,
                            sliding: null,
                            dargging: null,
                            targetElement: null
                        };

                base.isCssFinish = true;

                function getTouches(event) {
                    if (event.touches !== undefined) {
                        return {
                            x: event.touches[0].pageX,
                            y: event.touches[0].pageY
                        };
                    }

                    if (event.touches === undefined) {
                        if (event.pageX !== undefined) {
                            return {
                                x: event.pageX,
                                y: event.pageY
                            };
                        }
                        if (event.pageX === undefined) {
                            return {
                                x: event.clientX,
                                y: event.clientY
                            };
                        }
                    }
                }

                function swapEvents(type) {
                    if (type === "on") {
                        $(document).on(base.ev_types.move, dragMove);
                        $(document).on(base.ev_types.end, dragEnd);
                    } else if (type === "off") {
                        $(document).off(base.ev_types.move);
                        $(document).off(base.ev_types.end);
                    }
                }

                function dragStart(event) {
                    var ev = event.originalEvent || event || window.event,
                            position;

                    if (ev.which === 3) {
                        return false;
                    }
                    if (base.itemsAmount <= base.options.items) {
                        return;
                    }
                    if (base.isCssFinish === false && !base.options.dragBeforeAnimFinish) {
                        return false;
                    }
                    if (base.isCss3Finish === false && !base.options.dragBeforeAnimFinish) {
                        return false;
                    }

                    if (base.options.autoPlay !== false) {
                        window.clearInterval(base.autoPlayInterval);
                    }

                    if (base.browser.isTouch !== true && !base.$owlWrapper.hasClass("grabbing")) {
                        base.$owlWrapper.addClass("grabbing");
                    }

                    base.newPosX = 0;
                    base.newRelativeX = 0;

                    $(this).css(base.removeTransition());

                    position = $(this).position();
                    locals.relativePos = position.left;

                    locals.offsetX = getTouches(ev).x - position.left;
                    locals.offsetY = getTouches(ev).y - position.top;

                    swapEvents("on");

                    locals.sliding = false;
                    locals.targetElement = ev.target || ev.srcElement;
                }

                function dragMove(event) {
                    var ev = event.originalEvent || event || window.event,
                            minSwipe,
                            maxSwipe;

                    base.newPosX = getTouches(ev).x - locals.offsetX;
                    base.newPosY = getTouches(ev).y - locals.offsetY;
                    base.newRelativeX = base.newPosX - locals.relativePos;

                    if (typeof base.options.startDragging === "function" && locals.dragging !== true && base.newRelativeX !== 0) {
                        locals.dragging = true;
                        base.options.startDragging.apply(base, [base.$elem]);
                    }

                    if ((base.newRelativeX > 8 || base.newRelativeX < -8) && (base.browser.isTouch === true)) {
                        if (ev.preventDefault !== undefined) {
                            ev.preventDefault();
                        } else {
                            ev.returnValue = false;
                        }
                        locals.sliding = true;
                    }

                    if ((base.newPosY > 10 || base.newPosY < -10) && locals.sliding === false) {
                        $(document).off("touchmove.owl");
                    }

                    minSwipe = function () {
                        return base.newRelativeX / 5;
                    };

                    maxSwipe = function () {
                        return base.maximumPixels + base.newRelativeX / 5;
                    };

                    base.newPosX = Math.max(Math.min(base.newPosX, minSwipe()), maxSwipe());
                    if (base.browser.support3d === true) {
                        base.transition3d(base.newPosX);
                    } else {
                        base.css2move(base.newPosX);
                    }
                }

                function dragEnd(event) {
                    var ev = event.originalEvent || event || window.event,
                            newPosition,
                            handlers,
                            owlStopEvent;

                    ev.target = ev.target || ev.srcElement;

                    locals.dragging = false;

                    if (base.browser.isTouch !== true) {
                        base.$owlWrapper.removeClass("grabbing");
                    }

                    if (base.newRelativeX < 0) {
                        base.dragDirection = base.owl.dragDirection = "left";
                    } else {
                        base.dragDirection = base.owl.dragDirection = "right";
                    }

                    if (base.newRelativeX !== 0) {
                        newPosition = base.getNewPosition();
                        base.goTo(newPosition, false, "drag");
                        if (locals.targetElement === ev.target && base.browser.isTouch !== true) {
                            $(ev.target).on("click.disable", function (ev) {
                                ev.stopImmediatePropagation();
                                ev.stopPropagation();
                                ev.preventDefault();
                                $(ev.target).off("click.disable");
                            });
                            handlers = $._data(ev.target, "events").click;
                            owlStopEvent = handlers.pop();
                            handlers.splice(0, 0, owlStopEvent);
                        }
                    }
                    swapEvents("off");
                }
                base.$elem.on(base.ev_types.start, ".owl-wrapper", dragStart);
            },
            getNewPosition: function () {
                var base = this,
                        newPosition = base.closestItem();

                if (newPosition > base.maximumItem) {
                    base.currentItem = base.maximumItem;
                    newPosition = base.maximumItem;
                } else if (base.newPosX >= 0) {
                    newPosition = 0;
                    base.currentItem = 0;
                }
                return newPosition;
            },
            closestItem: function () {
                var base = this,
                        array = base.options.scrollPerPage === true ? base.pagesInArray : base.positionsInArray,
                        goal = base.newPosX,
                        closest = null;

                $.each(array, function (i, v) {
                    if (goal - (base.itemWidth / 20) > array[i + 1] && goal - (base.itemWidth / 20) < v && base.moveDirection() === "left") {
                        closest = v;
                        if (base.options.scrollPerPage === true) {
                            base.currentItem = $.inArray(closest, base.positionsInArray);
                        } else {
                            base.currentItem = i;
                        }
                    } else if (goal + (base.itemWidth / 20) < v && goal + (base.itemWidth / 20) > (array[i + 1] || array[i] - base.itemWidth) && base.moveDirection() === "right") {
                        if (base.options.scrollPerPage === true) {
                            closest = array[i + 1] || array[array.length - 1];
                            base.currentItem = $.inArray(closest, base.positionsInArray);
                        } else {
                            closest = array[i + 1];
                            base.currentItem = i + 1;
                        }
                    }
                });
                return base.currentItem;
            },
            moveDirection: function () {
                var base = this,
                        direction;
                if (base.newRelativeX < 0) {
                    direction = "right";
                    base.playDirection = "next";
                } else {
                    direction = "left";
                    base.playDirection = "prev";
                }
                return direction;
            },
            customEvents: function () {
                /*jslint unparam: true*/
                var base = this;
                base.$elem.on("owl.next", function () {
                    base.next();
                });
                base.$elem.on("owl.prev", function () {
                    base.prev();
                });
                base.$elem.on("owl.play", function (event, speed) {
                    base.options.autoPlay = speed;
                    base.play();
                    base.hoverStatus = "play";
                });
                base.$elem.on("owl.stop", function () {
                    base.stop();
                    base.hoverStatus = "stop";
                });
                base.$elem.on("owl.goTo", function (event, item) {
                    base.goTo(item);
                });
                base.$elem.on("owl.jumpTo", function (event, item) {
                    base.jumpTo(item);
                });
            },
            stopOnHover: function () {
                var base = this;
                if (base.options.stopOnHover === true && base.browser.isTouch !== true && base.options.autoPlay !== false) {
                    base.$elem.on("mouseover", function () {
                        base.stop();
                    });
                    base.$elem.on("mouseout", function () {
                        if (base.hoverStatus !== "stop") {
                            base.play();
                        }
                    });
                }
            },
            lazyLoad: function () {
                var base = this,
                        i,
                        $item,
                        itemNumber,
                        $lazyImg,
                        follow;

                if (base.options.lazyLoad === false) {
                    return false;
                }
                for (i = 0; i < base.itemsAmount; i += 1) {
                    $item = $(base.$owlItems[i]);

                    if ($item.data("owl-loaded") === "loaded") {
                        continue;
                    }

                    itemNumber = $item.data("owl-item");
                    $lazyImg = $item.find(".lazyOwl");

                    if (typeof $lazyImg.data("src") !== "string") {
                        $item.data("owl-loaded", "loaded");
                        continue;
                    }
                    if ($item.data("owl-loaded") === undefined) {
                        $lazyImg.hide();
                        $item.addClass("loading").data("owl-loaded", "checked");
                    }
                    if (base.options.lazyFollow === true) {
                        follow = itemNumber >= base.currentItem;
                    } else {
                        follow = true;
                    }
                    if (follow && itemNumber < base.currentItem + base.options.items && $lazyImg.length) {
                        base.lazyPreload($item, $lazyImg);
                    }
                }
            },
            lazyPreload: function ($item, $lazyImg) {
                var base = this,
                        iterations = 0,
                        isBackgroundImg;

                if ($lazyImg.prop("tagName") === "DIV") {
                    $lazyImg.css("background-image", "url(" + $lazyImg.data("src") + ")");
                    isBackgroundImg = true;
                } else {
                    $lazyImg[0].src = $lazyImg.data("src");
                }

                function showImage() {
                    $item.data("owl-loaded", "loaded").removeClass("loading");
                    $lazyImg.removeAttr("data-src");
                    if (base.options.lazyEffect === "fade") {
                        $lazyImg.fadeIn(400);
                    } else {
                        $lazyImg.show();
                    }
                    if (typeof base.options.afterLazyLoad === "function") {
                        base.options.afterLazyLoad.apply(this, [base.$elem]);
                    }
                }

                function checkLazyImage() {
                    iterations += 1;
                    if (base.completeImg($lazyImg.get(0)) || isBackgroundImg === true) {
                        showImage();
                    } else if (iterations <= 100) {//if image loads in less than 10 seconds 
                        window.setTimeout(checkLazyImage, 100);
                    } else {
                        showImage();
                    }
                }

                checkLazyImage();
            },
            autoHeight: function () {
                var base = this,
                        $currentimg = $(base.$owlItems[base.currentItem]).find("img"),
                        iterations;

                function addHeight() {
                    var $currentItem = $(base.$owlItems[base.currentItem]).height();
                    base.wrapperOuter.css("height", $currentItem + "px");
                    if (!base.wrapperOuter.hasClass("autoHeight")) {
                        window.setTimeout(function () {
                            base.wrapperOuter.addClass("autoHeight");
                        }, 0);
                    }
                }

                function checkImage() {
                    iterations += 1;
                    if (base.completeImg($currentimg.get(0))) {
                        addHeight();
                    } else if (iterations <= 100) { //if image loads in less than 10 seconds 
                        window.setTimeout(checkImage, 100);
                    } else {
                        base.wrapperOuter.css("height", ""); //Else remove height attribute
                    }
                }

                if ($currentimg.get(0) !== undefined) {
                    iterations = 0;
                    checkImage();
                } else {
                    addHeight();
                }
            },
            completeImg: function (img) {
                var naturalWidthType;

                if (!img.complete) {
                    return false;
                }
                naturalWidthType = typeof img.naturalWidth;
                if (naturalWidthType !== "undefined" && img.naturalWidth === 0) {
                    return false;
                }
                return true;
            },
            onVisibleItems: function () {
                var base = this,
                        i;

                if (base.options.addClassActive === true) {
                    base.$owlItems.removeClass("active");
                }
                base.visibleItems = [];
                for (i = base.currentItem; i < base.currentItem + base.options.items; i += 1) {
                    base.visibleItems.push(i);

                    if (base.options.addClassActive === true) {
                        $(base.$owlItems[i]).addClass("active");
                    }
                }
                base.owl.visibleItems = base.visibleItems;
            },
            transitionTypes: function (className) {
                var base = this;
                //Currently available: "fade", "backSlide", "goDown", "fadeUp"
                base.outClass = "owl-" + className + "-out";
                base.inClass = "owl-" + className + "-in";
            },
            singleItemTransition: function () {
                var base = this,
                        outClass = base.outClass,
                        inClass = base.inClass,
                        $currentItem = base.$owlItems.eq(base.currentItem),
                        $prevItem = base.$owlItems.eq(base.prevItem),
                        prevPos = Math.abs(base.positionsInArray[base.currentItem]) + base.positionsInArray[base.prevItem],
                        origin = Math.abs(base.positionsInArray[base.currentItem]) + base.itemWidth / 2,
                        animEnd = 'webkitAnimationEnd oAnimationEnd MSAnimationEnd animationend';

                base.isTransition = true;

                base.$owlWrapper
                        .addClass('owl-origin')
                        .css({
                            "-webkit-transform-origin": origin + "px",
                            "-moz-perspective-origin": origin + "px",
                            "perspective-origin": origin + "px"
                        });
                function transStyles(prevPos) {
                    return {
                        "position": "relative",
                        "left": prevPos + "px"
                    };
                }

                $prevItem
                        .css(transStyles(prevPos, 10))
                        .addClass(outClass)
                        .on(animEnd, function () {
                            base.endPrev = true;
                            $prevItem.off(animEnd);
                            base.clearTransStyle($prevItem, outClass);
                        });

                $currentItem
                        .addClass(inClass)
                        .on(animEnd, function () {
                            base.endCurrent = true;
                            $currentItem.off(animEnd);
                            base.clearTransStyle($currentItem, inClass);
                        });
            },
            clearTransStyle: function (item, classToRemove) {
                var base = this;
                item.css({
                    "position": "",
                    "left": ""
                }).removeClass(classToRemove);

                if (base.endPrev && base.endCurrent) {
                    base.$owlWrapper.removeClass('owl-origin');
                    base.endPrev = false;
                    base.endCurrent = false;
                    base.isTransition = false;
                }
            },
            owlStatus: function () {
                var base = this;
                base.owl = {
                    "userOptions": base.userOptions,
                    "baseElement": base.$elem,
                    "userItems": base.$userItems,
                    "owlItems": base.$owlItems,
                    "currentItem": base.currentItem,
                    "prevItem": base.prevItem,
                    "visibleItems": base.visibleItems,
                    "isTouch": base.browser.isTouch,
                    "browser": base.browser,
                    "dragDirection": base.dragDirection
                };
            },
            clearEvents: function () {
                var base = this;
                base.$elem.off(".owl owl mousedown.disableTextSelect");
                $(document).off(".owl owl");
                $(window).off("resize", base.resizer);
            },
            unWrap: function () {
                var base = this;
                if (base.$elem.children().length !== 0) {
                    base.$owlWrapper.unwrap();
                    base.$userItems.unwrap().unwrap();
                    if (base.owlControls) {
                        base.owlControls.remove();
                    }
                }
                base.clearEvents();
                base.$elem
                        .attr("style", base.$elem.data("owl-originalStyles") || "")
                        .attr("class", base.$elem.data("owl-originalClasses"));
            },
            destroy: function () {
                var base = this;
                base.stop();
                window.clearInterval(base.checkVisible);
                base.unWrap();
                base.$elem.removeData();
            },
            reinit: function (newOptions) {
                var base = this,
                        options = $.extend({}, base.userOptions, newOptions);
                base.unWrap();
                base.init(options, base.$elem);
            },
            addItem: function (htmlString, targetPosition) {
                var base = this,
                        position;

                if (!htmlString) {
                    return false;
                }

                if (base.$elem.children().length === 0) {
                    base.$elem.append(htmlString);
                    base.setVars();
                    return false;
                }
                base.unWrap();
                if (targetPosition === undefined || targetPosition === -1) {
                    position = -1;
                } else {
                    position = targetPosition;
                }
                if (position >= base.$userItems.length || position === -1) {
                    base.$userItems.eq(-1).after(htmlString);
                } else {
                    base.$userItems.eq(position).before(htmlString);
                }

                base.setVars();
            },
            removeItem: function (targetPosition) {
                var base = this,
                        position;

                if (base.$elem.children().length === 0) {
                    return false;
                }
                if (targetPosition === undefined || targetPosition === -1) {
                    position = -1;
                } else {
                    position = targetPosition;
                }

                base.unWrap();
                base.$userItems.eq(position).remove();
                base.setVars();
            }

        };

        $.fn.owlCarousel = function (options) {
            return this.each(function () {
                if ($(this).data("owl-init") === true) {
                    return false;
                }
                $(this).data("owl-init", true);
                var carousel = Object.create(Carousel);
                carousel.init(options, this);
                $.data(this, "owlCarousel", carousel);
            });
        };

        $.fn.owlCarousel.options = {
            items: 5,
            itemsCustom: false,
            itemsDesktop: [1199, 4],
            itemsDesktopSmall: [979, 3],
            itemsTablet: [768, 2],
            itemsTabletSmall: false,
            itemsMobile: [479, 1],
            singleItem: false,
            itemsScaleUp: false,
            slideSpeed: 200,
            paginationSpeed: 800,
            rewindSpeed: 1000,
            autoPlay: false,
            stopOnHover: false,
            navigation: false,
            navigationText: ["prev", "next"],
            rewindNav: true,
            scrollPerPage: false,
            pagination: true,
            paginationNumbers: false,
            responsive: true,
            responsiveRefreshRate: 200,
            responsiveBaseWidth: window,
            baseClass: "owl-carousel",
            theme: "owl-theme",
            lazyLoad: false,
            lazyFollow: true,
            lazyEffect: "fade",
            autoHeight: false,
            jsonPath: false,
            jsonSuccess: false,
            dragBeforeAnimFinish: true,
            mouseDrag: true,
            touchDrag: true,
            addClassActive: false,
            transitionStyle: false,
            beforeUpdate: false,
            afterUpdate: false,
            beforeInit: false,
            afterInit: false,
            beforeMove: false,
            afterMove: false,
            afterAction: false,
            startDragging: false,
            afterLazyLoad: false
        };
    }(jQuery, window, document));
});